package top.btcmarket;

import java.math.BigDecimal;
import java.text.DecimalFormat;

import org.apache.commons.lang3.StringUtils;

/**
 * 在java中，使用double进行运算，有时会出现精度丢失的问题，值会有那么0.00000***1偏差的偏差，导致匹配校验常常出现问题
 * 解决方案如下:
 * 加，乘，除都正常，而且，只要不是这种类型的相减，其他减法也正常
 * 原因：
 * 因为它的存储形式是二进制的10 进制转化成2进制进行运算可能会误差的，你也可以得到你想要的无精度损失的结果，前提是你将123写成1.23e+2, 123.12写成1.2312e+2双精度形式，
 * 否则从正整型123转化为双精度过程中就可能丢失那么一点精度，因为有限长度的寄存器位仍然无法表示无穷小的精度的。
 */
public class DoubleUtil {
    /**
     * 对double数据进行取精度.
     *
     * @param value        double数据.
     * @param scale        精度位数(保留的小数位数).
     * @param roundingMode 精度取值方式.
     * @return 精度计算后的数据.
     */
    public static double round(double value, int scale, int roundingMode) {
        BigDecimal bd = new BigDecimal(Double.valueOf(value));
        bd = bd.setScale(scale, roundingMode);
        double d = bd.doubleValue();
        bd = null;
        return d;
    }

    /**
     * 对double数据四舍五入
     *
     * @param value        double数据.
     * @param scale        精度位数(保留的小数位数).
     * @return 精度计算后的数据.
     */
    public static double round(double value, int scale) {
        return round(value, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 超出小数位数则截断
     *
     * @param value        double数据.
     * @param scale        精度位数(保留的小数位数).
     * @return 精度计算后的数据.
     */
    public static double roundDown(double value, int scale) {
        return round(value, scale, BigDecimal.ROUND_DOWN);
    }

    /**
     * 对double数据取整，默认四舍五入
     *
     * @param value
     * @return
     */
    public static long roundToLong(double value) {
        Double dou = round(value, 0, BigDecimal.ROUND_HALF_UP);
        return dou.longValue();
    }

    /**
     * double 相加
     *
     * @param d1
     * @param d2
     * @return
     */

    public static double sum(double d1, double d2) {

        BigDecimal bd1 = new BigDecimal(Double.toString(d1));

        BigDecimal bd2 = new BigDecimal(Double.toString(d2));

        return bd1.add(bd2).doubleValue();

    }


    /**
     * double 相减
     *
     * @param d1
     * @param d2
     * @return
     */

    public static double sub(double d1, double d2) {

        BigDecimal bd1 = new BigDecimal(Double.toString(d1));

        BigDecimal bd2 = new BigDecimal(Double.toString(d2));

        return bd1.subtract(bd2).doubleValue();

    }


    /**
     * double 乘法
     *
     * @param d1
     * @param d2
     * @return
     */

    public static double mul(double d1, double d2) {

        BigDecimal bd1 = new BigDecimal(Double.toString(d1));

        BigDecimal bd2 = new BigDecimal(Double.toString(d2));

        return bd1.multiply(bd2).doubleValue();

    }


    /**
     * double 除法
     *
     * @param d1
     * @param d2
     * @param scale 四舍五入 小数点位数
     * @return
     */

    public static double div(double d1, double d2, int scale) {

        //  当然在此之前，你要判断分母是否为0，

        //  为0你可以根据实际需求做相应的处理

        BigDecimal bd1 = new BigDecimal(Double.toString(d1));

        BigDecimal bd2 = new BigDecimal(Double.toString(d2));

        return bd1.divide(bd2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

    }

    //判断是否为0
    public static boolean  isZero(double d){
        if(Math.abs(d) > 0.00000001){
            return false;
        }
        return true;

    }
    
    public static String doubleToFormat(double value){
    	String format = String.format("%.8f", value);
    	return format ;
    }
    
    public static String doubleToStr(double value) {  
        String retValue = null;  
        DecimalFormat df = new DecimalFormat();  
        df.setMinimumFractionDigits(0);  
        df.setMaximumFractionDigits(8);  
        retValue = df.format(round(value,8));  
        retValue = retValue.replaceAll(",", "");  
        return retValue;  
    } 
    
    /**
     * 0.23446886454  -> 0.23446886
     * 10.23446886454  ->  10.23446886
     * 0.2344 -> 0.2344
     * 10.2344 -> 10.2344
     * 10 -> 10
     * @param doubleStr
     * @param dotLen
     * @return
     */
    public static String truncateDouble(String doubleStr,int dotLen){
    	StringBuffer sb = new StringBuffer();
    	if(doubleStr != null && doubleStr.trim().length()>0){
    		int len = doubleStr.indexOf(".");
    		if(len>0){
    			String[] numberSplit = doubleStr.split("\\.");
				String subStr = numberSplit[1];
				if(subStr.length()>dotLen){
					subStr = subStr.substring(0,dotLen);
				}
				
				sb.append(numberSplit[0]).append(".").append(subStr);
    		}
    	}
    	
    	if(sb.length()<=0){
    		sb.append(doubleStr);
    	}
    	
    	return sb.toString() ;
    }
    
    public static BigDecimal convertAmountToSend(String amount) {
		// TODO Auto-generated method stub
		if(StringUtils.isNotEmpty(amount)){
			amount=DoubleUtil.truncateDouble(amount, 8);
			//10的8次方
			BigDecimal convertNumber= new BigDecimal(100000000);
			BigDecimal amountNum = new BigDecimal(amount);
			return amountNum.multiply(convertNumber);
		}
		
		return null;
	}
    
    
    public static void main(String[] args) {
    	
    	System.out.println(truncateDouble("0.2344",8));
    	System.out.println(truncateDouble("10.2344",8));
    	System.out.println(truncateDouble("103333333332344",8));
    	System.out.println(convertAmountToShow("103333333332344"));
    	System.out.println(convertAmountToShow("14234"));
    	
		System.out.println(roundDown(0.123456789,8));
	}

	public static BigDecimal convertAmountToShow(String fee) {
		// TODO fee  需要为long的字符
		if(StringUtils.isNotEmpty(fee)){
			fee=DoubleUtil.truncateDouble(fee, 8);
			//10的8次方
			BigDecimal convertNumber= new BigDecimal(100000000);
			BigDecimal amountNum = new BigDecimal(fee);
			return amountNum.divide(convertNumber);
		}
		return null;
	}

	
   
}
